package com.itheima.leetcode.od.c.string;

import java.util.*;
import java.io.*;

/**
 * <h3>流量波峰</h3>
 */
public class TrafficPeak {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String line = reader.readLine();

        String[] parts = line.trim().split("\\s+");
        int[] nums = new int[parts.length];
        for (int i = 0; i < parts.length; i++) {
            nums[i] = Integer.parseInt(parts[i]);
        }

        System.out.println(findMinPeakDistance(nums));
    }

    /**
     * 单调栈 + 动态规划
     *
     * @param nums
     * @return
     */
    public static int findMinPeakDistance(int[] nums) {
        int n = nums.length;
        if (n < 3) {
            return -1;
        }

        // --- 使用单调栈 ---
        // left 存储 nums[i] 左边第一个比它小的元素的索引
        // right 存储 nums[i] 右边第一个比它小的元素的索引

        // 1. 从左到右遍历，找每个元素左边第一个更小的
        int[] left = new int[n];
        Arrays.fill(left, -1);
        Deque<Integer> stack = new ArrayDeque<>(); // 使用 Deque 作为栈
        for (int i = 0; i < n; i++) {
            while (!stack.isEmpty() && nums[stack.peek()] >= nums[i]) {
                stack.pop();
            }
            if (!stack.isEmpty()) {
                left[i] = stack.peek();
            }
            stack.push(i);
        }

        // 2. 从右到左遍历，找每个元素右边第一个更小的
        int[] right = new int[n];
        Arrays.fill(right, -1);
        stack.clear(); // 清空栈以便复用
        for (int i = n - 1; i >= 0; i--) {
            while (!stack.isEmpty() && nums[stack.peek()] >= nums[i]) {
                stack.pop();
            }
            if (!stack.isEmpty()) {
                right[i] = stack.peek();
            }
            stack.push(i);
        }

        // 3. 遍历所有可能的波峰点 j，计算最小距离
        int min_dist = Integer.MAX_VALUE;
        boolean found = false;

        // j 可以是任何一个点，只要它左右都有比它小的点
        for (int j = 0; j < n; j++) {
            // 如果 j 左边和右边都找到了比它小的点
            if (left[j] != -1 && right[j] != -1) {
                int i = left[j];
                int k = right[j];
                // 更新最小距离 k - i
                min_dist = Math.min(min_dist, k - i);
                found = true;
            }
        }

        // 如果找到了，返回最小距离；否则返回 -1
        return found ? min_dist : -1;
    }
}